home *** CD-ROM | disk | FTP | other *** search
/ ETO Development Tools 1 / ETO Development Tools 1.iso / Essentials / Developer Essentials Jul 90 / Programming / MPW Interfaces & Libraries 3.1 / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1989-10-13  |  25.5 KB  |  926 lines  |  [TEXT/MPS ]
  1. {
  2. Created: Saturday, September 16, 1989 at 10:20 PM
  3.     Quickdraw.p
  4.     Pascal Interface to the Macintosh Libraries
  5.  
  6.     Copyright Apple Computer, Inc.    1985-1989
  7.     All rights reserved
  8. }
  9.  
  10.  
  11. {$IFC UNDEFINED UsingIncludes}
  12. {$SETC UsingIncludes := 0}
  13. {$ENDC}
  14.  
  15. {$IFC NOT UsingIncludes}
  16.     UNIT Quickdraw;
  17.     INTERFACE
  18. {$ENDC}
  19.  
  20. {$IFC UNDEFINED UsingQuickdraw}
  21. {$SETC UsingQuickdraw := 1}
  22.  
  23. {$I+}
  24. {$SETC QuickdrawIncludes := UsingIncludes}
  25. {$SETC UsingIncludes := 1}
  26. {$IFC UNDEFINED UsingTypes}
  27. {$I $$Shell(PInterfaces)Types.p}
  28. {$ENDC}
  29. {$SETC UsingIncludes := QuickdrawIncludes}
  30.  
  31. CONST
  32. invalColReq = -1;                            {invalid color table request}
  33. srcCopy = 0;                                {the 16 transfer modes}
  34. srcOr = 1;
  35. srcXor = 2;
  36. srcBic = 3;
  37. notSrcCopy = 4;
  38. notSrcOr = 5;
  39. notSrcXor = 6;
  40. notSrcBic = 7;
  41. patCopy = 8;
  42. patOr = 9;
  43. patXor = 10;
  44. patBic = 11;
  45. notPatCopy = 12;
  46. notPatOr = 13;
  47. notPatXor = 14;
  48. notPatBic = 15;
  49.  
  50. { Arithmetic transfer modes }
  51.  
  52. blend = 32;
  53. addPin = 33;
  54. addOver = 34;
  55. subPin = 35;
  56. addMax = 37;
  57. subOver = 38;
  58. adMin = 39;
  59.  
  60. { Transparent mode constant }
  61.  
  62. transparent = 36;
  63.  
  64. { QuickDraw color separation constants
  65.  
  66.  }
  67.  
  68. normalBit = 0;                                {normal screen mapping}
  69. inverseBit = 1;                             {inverse screen mapping}
  70. redBit = 4;                                 {RGB additive mapping}
  71. greenBit = 3;
  72. blueBit = 2;
  73. cyanBit = 8;                                {CMYBk subtractive mapping}
  74. magentaBit = 7;
  75. yellowBit = 6;
  76. blackBit = 5;
  77. blackColor = $0021;                         {colors expressed in these mappings}
  78. whiteColor = $001E;
  79. redColor = $00D1;
  80. greenColor = $0149;
  81. blueColor = $0185;
  82. cyanColor = $010D;
  83. magentaColor = $0095;
  84. yellowColor = $0059;
  85. picLParen = 0;                                {standard picture comments}
  86. picRParen = 1;
  87. clutType = 0;                                {0 if lookup table}
  88. fixedType = 1;                                {1 if fixed table}
  89. directType = 2;                             {2 if direct values}
  90. gdDevType = 0;                                {0 = monochrome 1 = color}
  91. ramInit = 10;                                {1 if initialized from 'scrn' resource}
  92. mainScreen = 11;                            { 1 if main screen }
  93. allInit = 12;                                { 1 if all devices initialized }
  94. screenDevice = 13;                            {1 if screen device [not used]}
  95. noDriver = 14;                                { 1 if no driver for this GDevice }
  96. screenActive = 15;                            {1 if in use}
  97. hiliteBit = 7;                                {flag bit in HiliteMode (lowMem flag)}
  98. pHiliteBit = 0;                             {flag bit in HiliteMode used with BitClr procedure}
  99. defQDColors = 127;                            {resource ID of clut for default QDColors}
  100.  
  101.  
  102. TYPE
  103.  
  104. GrafVerb = (frame,paint,erase,invert,fill);
  105.  
  106. PixelType = (chunky,chunkyPlanar,planar);
  107.  
  108. StyleItem = (bold,italic,underline,outline,shadow,condense,extend);
  109.  
  110.  
  111. QDByte = SignedByte;
  112.  
  113. QDPtr = Ptr;                                { blind pointer }
  114.  
  115. QDHandle = Handle;                            { blind handle }
  116.  
  117. QDErr = INTEGER;
  118.  
  119. PatPtr = ^Pattern;
  120. PatHandle = ^PatPtr;
  121.  
  122. Pattern = PACKED ARRAY [0..7] OF 0..255;
  123.  
  124. Bits16 = ARRAY [0..15] OF INTEGER;
  125.  
  126. Style = SET OF StyleItem;
  127.  
  128. FontInfo = RECORD
  129.     ascent: INTEGER;
  130.     descent: INTEGER;
  131.     widMax: INTEGER;
  132.     leading: INTEGER;
  133.     END;
  134.  
  135. BitMapPtr = ^BitMap;
  136. BitMapHandle = ^BitMapPtr;
  137. BitMap = RECORD
  138.     baseAddr: Ptr;
  139.     rowBytes: INTEGER;
  140.     bounds: Rect;
  141.     END;
  142.  
  143. CursPtr = ^Cursor;
  144. CursHandle = ^CursPtr;
  145. Cursor = RECORD
  146.     data: Bits16;
  147.     mask: Bits16;
  148.     hotSpot: Point;
  149.     END;
  150.  
  151. PenState = RECORD
  152.     pnLoc: Point;
  153.     pnSize: Point;
  154.     pnMode: INTEGER;
  155.     pnPat: Pattern;
  156.     END;
  157.  
  158. RgnPtr = ^Region;
  159. RgnHandle = ^RgnPtr;
  160. Region = RECORD
  161.     rgnSize: INTEGER;                        {size in bytes}
  162.     rgnBBox: Rect;                            {enclosing rectangle}
  163.     END;
  164.  
  165. PicPtr = ^Picture;
  166. PicHandle = ^PicPtr;
  167. Picture = RECORD
  168.     picSize: INTEGER;
  169.     picFrame: Rect;
  170.     END;
  171.  
  172. PolyPtr = ^Polygon;
  173. PolyHandle = ^PolyPtr;
  174. Polygon = RECORD
  175.     polySize: INTEGER;
  176.     polyBBox: Rect;
  177.     polyPoints: ARRAY [0..0] OF Point;
  178.     END;
  179.  
  180. QDProcsPtr = ^QDProcs;
  181. QDProcs = RECORD
  182.     textProc: Ptr;
  183.     lineProc: Ptr;
  184.     rectProc: Ptr;
  185.     rRectProc: Ptr;
  186.     ovalProc: Ptr;
  187.     arcProc: Ptr;
  188.     polyProc: Ptr;
  189.     rgnProc: Ptr;
  190.     bitsProc: Ptr;
  191.     commentProc: Ptr;
  192.     txMeasProc: Ptr;
  193.     getPicProc: Ptr;
  194.     putPicProc: Ptr;
  195.     END;
  196.  
  197. GrafPtr = ^GrafPort;
  198. GrafPort = RECORD
  199.     device: INTEGER;
  200.     portBits: BitMap;
  201.     portRect: Rect;
  202.     visRgn: RgnHandle;
  203.     clipRgn: RgnHandle;
  204.     bkPat: Pattern;
  205.     fillPat: Pattern;
  206.     pnLoc: Point;
  207.     pnSize: Point;
  208.     pnMode: INTEGER;
  209.     pnPat: Pattern;
  210.     pnVis: INTEGER;
  211.     txFont: INTEGER;
  212.     txFace: Style;                            {txFace is unpacked byte but push as short}
  213.     txMode: INTEGER;
  214.     txSize: INTEGER;
  215.     spExtra: Fixed;
  216.     fgColor: LONGINT;
  217.     bkColor: LONGINT;
  218.     colrBit: INTEGER;
  219.     patStretch: INTEGER;
  220.     picSave: Handle;
  221.     rgnSave: Handle;
  222.     polySave: Handle;
  223.     grafProcs: QDProcsPtr;
  224.     END;
  225.  
  226. WindowPtr = GrafPtr;
  227.  
  228. RGBColor = RECORD
  229.     red: INTEGER;                            {magnitude of red component}
  230.     green: INTEGER;                         {magnitude of green component}
  231.     blue: INTEGER;                            {magnitude of blue component}
  232.     END;
  233.  
  234. ColorSpec = RECORD
  235.     value: INTEGER;                         {index or other value}
  236.     rgb: RGBColor;                            {true color}
  237.     END;
  238.  
  239. CSpecArray = ARRAY [0..0] OF ColorSpec;
  240.  
  241. CTabPtr = ^ColorTable;
  242. CTabHandle = ^CTabPtr;
  243. ColorTable = RECORD
  244.     ctSeed: LONGINT;                        {unique identifier for table}
  245.     ctFlags: INTEGER;                        {high bit: 0 = PixMap; 1 = device}
  246.     ctSize: INTEGER;                        {number of entries in CTTable}
  247.     ctTable: CSpecArray;                    {array [0..0] of ColorSpec}
  248.     END;
  249.  
  250. MatchRec = RECORD
  251.     red: INTEGER;
  252.     green: INTEGER;
  253.     blue: INTEGER;
  254.     matchData: LONGINT;
  255.     END;
  256.  
  257. PixMapPtr = ^PixMap;
  258. PixMapHandle = ^PixMapPtr;
  259. PixMap = RECORD
  260.     baseAddr: Ptr;                            {pointer to pixels}
  261.     rowBytes: INTEGER;                        {offset to next line}
  262.     bounds: Rect;                            {encloses bitmap}
  263.     pmVersion: INTEGER;                     {pixMap version number}
  264.     packType: INTEGER;                        {defines packing format}
  265.     packSize: LONGINT;                        {length of pixel data}
  266.     hRes: Fixed;                            {horiz. resolution (ppi)}
  267.     vRes: Fixed;                            {vert. resolution (ppi)}
  268.     pixelType: INTEGER;                     {defines pixel type}
  269.     pixelSize: INTEGER;                     {# bits in pixel}
  270.     cmpCount: INTEGER;                        {# components in pixel}
  271.     cmpSize: INTEGER;                        {# bits per component}
  272.     planeBytes: LONGINT;                    {offset to next plane}
  273.     pmTable: CTabHandle;                    {color map for this pixMap}
  274.     pmReserved: LONGINT;                    {for future use. MUST BE 0}
  275.     END;
  276.  
  277. PixPatPtr = ^PixPat;
  278. PixPatHandle = ^PixPatPtr;
  279. PixPat = RECORD
  280.     patType: INTEGER;                        {type of pattern}
  281.     patMap: PixMapHandle;                    {the pattern's pixMap}
  282.     patData: Handle;                        {pixmap's data}
  283.     patXData: Handle;                        {expanded Pattern data}
  284.     patXValid: INTEGER;                     {flags whether expanded Pattern valid}
  285.     patXMap: Handle;                        {Handle to expanded Pattern data}
  286.     pat1Data: Pattern;                        {old-Style pattern/RGB color}
  287.     END;
  288.  
  289. CCrsrPtr = ^CCrsr;
  290. CCrsrHandle = ^CCrsrPtr;
  291. CCrsr = RECORD
  292.     crsrType: INTEGER;                        {type of cursor}
  293.     crsrMap: PixMapHandle;                    {the cursor's pixmap}
  294.     crsrData: Handle;                        {cursor's data}
  295.     crsrXData: Handle;                        {expanded cursor data}
  296.     crsrXValid: INTEGER;                    {depth of expanded data (0 if none)}
  297.     crsrXHandle: Handle;                    {future use}
  298.     crsr1Data: Bits16;                        {one-bit cursor}
  299.     crsrMask: Bits16;                        {cursor's mask}
  300.     crsrHotSpot: Point;                     {cursor's hotspot}
  301.     crsrXTable: LONGINT;                    {private}
  302.     crsrID: LONGINT;                        {private}
  303.     END;
  304.  
  305. CIconPtr = ^CIcon;
  306. CIconHandle = ^CIconPtr;
  307. CIcon = RECORD
  308.     iconPMap: PixMap;                        {the icon's pixMap}
  309.     iconMask: BitMap;                        {the icon's mask}
  310.     iconBMap: BitMap;                        {the icon's bitMap}
  311.     iconData: Handle;                        {the icon's data}
  312.     iconMaskData: ARRAY [0..0] OF INTEGER;    {icon's mask and BitMap data}
  313.     END;
  314.  
  315. GammaTblPtr = ^GammaTbl;
  316. GammaTblHandle = ^GammaTblPtr;
  317. GammaTbl = RECORD
  318.     gVersion: INTEGER;                        {gamma version number}
  319.     gType: INTEGER;                         {gamma data type}
  320.     gFormulaSize: INTEGER;                    {Formula data size}
  321.     gChanCnt: INTEGER;                        {number of channels of data}
  322.     gDataCnt: INTEGER;                        {number of values/channel}
  323.     gDataWidth: INTEGER;                    {bits/corrected value (data packed to next larger byte size)}
  324.     gFormulaData: ARRAY [0..0] OF INTEGER;    {data for formulas followed by gamma values}
  325.     END;
  326.  
  327. ITabPtr = ^ITab;
  328. ITabHandle = ^ITabPtr;
  329. ITab = RECORD
  330.     iTabSeed: LONGINT;                        {copy of CTSeed from source CTable}
  331.     iTabRes: INTEGER;                        {bits/channel resolution of iTable}
  332.     iTTable: ARRAY [0..0] OF SignedByte;    {byte colortable index values}
  333.     END;
  334.  
  335. SProcPtr = ^SProcRec;
  336. SProcHndl = ^SProcPtr;
  337. SProcRec = RECORD
  338.     nxtSrch: Handle;                        {Handle to next SProcRec}
  339.     srchProc: ProcPtr;                        {pointer to search procedure}
  340.     END;
  341.  
  342. CProcPtr = ^CProcRec;
  343. CProcHndl = ^CProcPtr;
  344. CProcRec = RECORD
  345.     nxtComp: CProcHndl;                     {CProcHndl Handle to next CProcRec}
  346.     compProc: ProcPtr;                        {pointer to complement procedure}
  347.     END;
  348.  
  349. GDPtr = ^GDevice;
  350. GDHandle = ^GDPtr;
  351. GDevice = RECORD
  352.     gdRefNum: INTEGER;                        {driver's unit number}
  353.     gdID: INTEGER;                            {client ID for search procs}
  354.     gdType: INTEGER;                        {fixed/CLUT/direct}
  355.     gdITable: ITabHandle;                    {Handle to inverse lookup table}
  356.     gdResPref: INTEGER;                     {preferred resolution of GDITable}
  357.     gdSearchProc: SProcHndl;                {search proc list head}
  358.     gdCompProc: CProcHndl;                    {complement proc list}
  359.     gdFlags: INTEGER;                        {grafDevice flags word}
  360.     gdPMap: PixMapHandle;                    {describing pixMap}
  361.     gdRefCon: LONGINT;                        {reference value}
  362.     gdNextGD: GDHandle;                     {GDHandle Handle of next gDevice}
  363.     gdRect: Rect;                            { device's bounds in global coordinates}
  364.     gdMode: LONGINT;                        {device's current mode}
  365.     gdCCBytes: INTEGER;                     {depth of expanded cursor data}
  366.     gdCCDepth: INTEGER;                     {depth of expanded cursor data}
  367.     gdCCXData: Handle;                        {Handle to cursor's expanded data}
  368.     gdCCXMask: Handle;                        {Handle to cursor's expanded mask}
  369.     gdReserved: LONGINT;                    {future use. MUST BE 0}
  370.     END;
  371.  
  372. GVarPtr = ^GrafVars;
  373. GVarHandle = ^GVarPtr;
  374. GrafVars = RECORD
  375.     rgbOpColor: RGBColor;                    {color for addPin  subPin and average}
  376.     rgbHiliteColor: RGBColor;                {color for hiliting}
  377.     pmFgColor: Handle;                        {palette Handle for foreground color}
  378.     pmFgIndex: INTEGER;                     {index value for foreground}
  379.     pmBkColor: Handle;                        {palette Handle for background color}
  380.     pmBkIndex: INTEGER;                     {index value for background}
  381.     pmFlags: INTEGER;                        {flags for Palette Manager}
  382.     END;
  383.  
  384. CQDProcsPtr = ^CQDProcs;
  385. CQDProcs = RECORD
  386.     textProc: Ptr;
  387.     lineProc: Ptr;
  388.     rectProc: Ptr;
  389.     rRectProc: Ptr;
  390.     ovalProc: Ptr;
  391.     arcProc: Ptr;
  392.     polyProc: Ptr;
  393.     rgnProc: Ptr;
  394.     bitsProc: Ptr;
  395.     commentProc: Ptr;
  396.     txMeasProc: Ptr;
  397.     getPicProc: Ptr;
  398.     putPicProc: Ptr;
  399.     opcodeProc: Ptr;                        {fields added to QDProcs}
  400.     newProc1: Ptr;
  401.     newProc2: Ptr;
  402.     newProc3: Ptr;
  403.     newProc4: Ptr;
  404.     newProc5: Ptr;
  405.     newProc6: Ptr;
  406.     END;
  407.  
  408. CGrafPtr = ^CGrafPort;
  409. CGrafPort = RECORD
  410.     device: INTEGER;
  411.     portPixMap: PixMapHandle;                {port's pixel map}
  412.     portVersion: INTEGER;                    {high 2 bits always set}
  413.     grafVars: Handle;                        {Handle to more fields}
  414.     chExtra: INTEGER;                        {character extra}
  415.     pnLocHFrac: INTEGER;                    {pen fraction}
  416.     portRect: Rect;
  417.     visRgn: RgnHandle;
  418.     clipRgn: RgnHandle;
  419.     bkPixPat: PixPatHandle;                 {background pattern}
  420.     rgbFgColor: RGBColor;                    {RGB components of fg}
  421.     rgbBkColor: RGBColor;                    {RGB components of bk}
  422.     pnLoc: Point;
  423.     pnSize: Point;
  424.     pnMode: INTEGER;
  425.     pnPixPat: PixPatHandle;                 {pen's pattern}
  426.     fillPixPat: PixPatHandle;                {fill pattern}
  427.     pnVis: INTEGER;
  428.     txFont: INTEGER;
  429.     txFace: Style;                            {txFace is unpacked byte  push as short}
  430.     txMode: INTEGER;
  431.     txSize: INTEGER;
  432.     spExtra: Fixed;
  433.     fgColor: LONGINT;
  434.     bkColor: LONGINT;
  435.     colrBit: INTEGER;
  436.     patStretch: INTEGER;
  437.     picSave: Handle;
  438.     rgnSave: Handle;
  439.     polySave: Handle;
  440.     grafProcs: CQDProcsPtr;
  441.     END;
  442.  
  443. CWindowPtr = CGrafPtr;
  444.  
  445. ReqListRec = RECORD
  446.     reqLSize: INTEGER;                        {request list size}
  447.     reqLData: ARRAY [0..0] OF INTEGER;        {request list data}
  448.     END;
  449.  
  450. VAR
  451. {$PUSH}
  452. {$J+}
  453.     thePort: GrafPtr;
  454.     white: Pattern;
  455.     black: Pattern;
  456.     gray: Pattern;
  457.     ltGray: Pattern;
  458.     dkGray: Pattern;
  459.     arrow: Cursor;
  460.     screenBits: BitMap;
  461.     randSeed: LONGINT;
  462. {$POP}
  463.  
  464.  
  465.  
  466. PROCEDURE InitGraf(globalPtr: Ptr);
  467.     INLINE $A86E;
  468. PROCEDURE OpenPort(port: GrafPtr);
  469.     INLINE $A86F;
  470. PROCEDURE InitPort(port: GrafPtr);
  471.     INLINE $A86D;
  472. PROCEDURE ClosePort(port: GrafPtr);
  473.     INLINE $A87D;
  474. PROCEDURE SetPort(port: GrafPtr);
  475.     INLINE $A873;
  476. PROCEDURE GetPort(VAR port: GrafPtr);
  477.     INLINE $A874;
  478. PROCEDURE GrafDevice(device: INTEGER);
  479.     INLINE $A872;
  480. PROCEDURE SetPortBits(bm: BitMap);
  481.     INLINE $A875;
  482. PROCEDURE PortSize(width: INTEGER;height: INTEGER);
  483.     INLINE $A876;
  484. PROCEDURE MovePortTo(leftGlobal: INTEGER;topGlobal: INTEGER);
  485.     INLINE $A877;
  486. PROCEDURE SetOrigin(h: INTEGER;v: INTEGER);
  487.     INLINE $A878;
  488. PROCEDURE SetClip(rgn: RgnHandle);
  489.     INLINE $A879;
  490. PROCEDURE GetClip(rgn: RgnHandle);
  491.     INLINE $A87A;
  492. PROCEDURE ClipRect(r: Rect);
  493.     INLINE $A87B;
  494. PROCEDURE BackPat(pat: Pattern);
  495.     INLINE $A87C;
  496. PROCEDURE InitCursor;
  497.     INLINE $A850;
  498. PROCEDURE SetCursor(crsr: Cursor);
  499.     INLINE $A851;
  500. PROCEDURE HideCursor;
  501.     INLINE $A852;
  502. PROCEDURE ShowCursor;
  503.     INLINE $A853;
  504. PROCEDURE ObscureCursor;
  505.     INLINE $A856;
  506. PROCEDURE HidePen;
  507.     INLINE $A896;
  508. PROCEDURE ShowPen;
  509.     INLINE $A897;
  510. PROCEDURE GetPen(VAR pt: Point);
  511.     INLINE $A89A;
  512. PROCEDURE GetPenState(VAR pnState: PenState);
  513.     INLINE $A898;
  514. PROCEDURE SetPenState(pnState: PenState);
  515.     INLINE $A899;
  516. PROCEDURE PenSize(width: INTEGER;height: INTEGER);
  517.     INLINE $A89B;
  518. PROCEDURE PenMode(mode: INTEGER);
  519.     INLINE $A89C;
  520. PROCEDURE PenPat(pat: Pattern);
  521.     INLINE $A89D;
  522. PROCEDURE PenNormal;
  523.     INLINE $A89E;
  524. PROCEDURE MoveTo(h: INTEGER;v: INTEGER);
  525.     INLINE $A893;
  526. PROCEDURE Move(dh: INTEGER;dv: INTEGER);
  527.     INLINE $A894;
  528. PROCEDURE LineTo(h: INTEGER;v: INTEGER);
  529.     INLINE $A891;
  530. PROCEDURE Line(dh: INTEGER;dv: INTEGER);
  531.     INLINE $A892;
  532. PROCEDURE TextFont(font: INTEGER);
  533.     INLINE $A887;
  534. PROCEDURE TextFace(face: Style);
  535.     INLINE $A888;
  536. PROCEDURE TextMode(mode: INTEGER);
  537.     INLINE $A889;
  538. PROCEDURE TextSize(size: INTEGER);
  539.     INLINE $A88A;
  540. PROCEDURE SpaceExtra(extra: Fixed);
  541.     INLINE $A88E;
  542. PROCEDURE DrawChar(ch: CHAR);
  543.     INLINE $A883;
  544. PROCEDURE DrawString(s: Str255);
  545.     INLINE $A884;
  546. PROCEDURE DrawText(textBuf: Ptr;firstByte: INTEGER;byteCount: INTEGER);
  547.     INLINE $A885;
  548. FUNCTION CharWidth(ch: CHAR): INTEGER;
  549.     INLINE $A88D;
  550. FUNCTION StringWidth(s: Str255): INTEGER;
  551.     INLINE $A88C;
  552. FUNCTION TextWidth(textBuf: Ptr;firstByte: INTEGER;byteCount: INTEGER): INTEGER;
  553.     INLINE $A886;
  554. PROCEDURE MeasureText(count: INTEGER;textAddr: Ptr;charLocs: Ptr);
  555.     INLINE $A837;
  556. PROCEDURE GetFontInfo(VAR info: FontInfo);
  557.     INLINE $A88B;
  558. PROCEDURE ForeColor(color: LONGINT);
  559.     INLINE $A862;
  560. PROCEDURE BackColor(color: LONGINT);
  561.     INLINE $A863;
  562. PROCEDURE ColorBit(whichBit: INTEGER);
  563.     INLINE $A864;
  564. PROCEDURE SetRect(VAR r: Rect;left: INTEGER;top: INTEGER;right: INTEGER;
  565.     bottom: INTEGER);
  566.     INLINE $A8A7;
  567. PROCEDURE OffsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  568.     INLINE $A8A8;
  569. PROCEDURE InsetRect(VAR r: Rect;dh: INTEGER;dv: INTEGER);
  570.     INLINE $A8A9;
  571. FUNCTION SectRect(src1: Rect;src2: Rect;VAR dstRect: Rect): BOOLEAN;
  572.     INLINE $A8AA;
  573. PROCEDURE UnionRect(src1: Rect;src2: Rect;VAR dstRect: Rect);
  574.     INLINE $A8AB;
  575. FUNCTION EqualRect(rect1: Rect;rect2: Rect): BOOLEAN;
  576.     INLINE $A8A6;
  577. FUNCTION EmptyRect(r: Rect): BOOLEAN;
  578.     INLINE $A8AE;
  579. PROCEDURE FrameRect(r: Rect);
  580.     INLINE $A8A1;
  581. PROCEDURE PaintRect(r: Rect);
  582.     INLINE $A8A2;
  583. PROCEDURE EraseRect(r: Rect);
  584.     INLINE $A8A3;
  585. PROCEDURE InvertRect(r: Rect);
  586.     INLINE $A8A4;
  587. PROCEDURE FillRect(r: Rect;pat: Pattern);
  588.     INLINE $A8A5;
  589. PROCEDURE FrameOval(r: Rect);
  590.     INLINE $A8B7;
  591. PROCEDURE PaintOval(r: Rect);
  592.     INLINE $A8B8;
  593. PROCEDURE EraseOval(r: Rect);
  594.     INLINE $A8B9;
  595. PROCEDURE InvertOval(r: Rect);
  596.     INLINE $A8BA;
  597. PROCEDURE FillOval(r: Rect;pat: Pattern);
  598.     INLINE $A8BB;
  599. PROCEDURE FrameRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  600.     INLINE $A8B0;
  601. PROCEDURE PaintRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  602.     INLINE $A8B1;
  603. PROCEDURE EraseRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  604.     INLINE $A8B2;
  605. PROCEDURE InvertRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  606.     INLINE $A8B3;
  607. PROCEDURE FillRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  608.     pat: Pattern);
  609.     INLINE $A8B4;
  610. PROCEDURE FrameArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  611.     INLINE $A8BE;
  612. PROCEDURE PaintArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  613.     INLINE $A8BF;
  614. PROCEDURE EraseArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  615.     INLINE $A8C0;
  616. PROCEDURE InvertArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  617.     INLINE $A8C1;
  618. PROCEDURE FillArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pat: Pattern);
  619.     INLINE $A8C2;
  620. FUNCTION NewRgn: RgnHandle;
  621.     INLINE $A8D8;
  622. PROCEDURE OpenRgn;
  623.     INLINE $A8DA;
  624. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  625.     INLINE $A8DB;
  626. FUNCTION BitMapToRegion(region: RgnHandle;bMap: BitMap): OSErr;
  627.     INLINE $A8D7;
  628. PROCEDURE DisposeRgn(rgn: RgnHandle);
  629.     INLINE $A8D9;
  630. PROCEDURE CopyRgn(srcRgn: RgnHandle;dstRgn: RgnHandle);
  631.     INLINE $A8DC;
  632. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  633.     INLINE $A8DD;
  634. PROCEDURE SetRectRgn(rgn: RgnHandle;left: INTEGER;top: INTEGER;right: INTEGER;
  635.     bottom: INTEGER);
  636.     INLINE $A8DE;
  637. PROCEDURE RectRgn(rgn: RgnHandle;r: Rect);
  638.     INLINE $A8DF;
  639. PROCEDURE OffsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  640.     INLINE $A8E0;
  641. PROCEDURE InsetRgn(rgn: RgnHandle;dh: INTEGER;dv: INTEGER);
  642.     INLINE $A8E1;
  643. PROCEDURE SectRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  644.     INLINE $A8E4;
  645. PROCEDURE UnionRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  646.     INLINE $A8E5;
  647. PROCEDURE DiffRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  648.     INLINE $A8E6;
  649. PROCEDURE XorRgn(srcRgnA: RgnHandle;srcRgnB: RgnHandle;dstRgn: RgnHandle);
  650.     INLINE $A8E7;
  651. FUNCTION RectInRgn(r: Rect;rgn: RgnHandle): BOOLEAN;
  652.     INLINE $A8E9;
  653. FUNCTION EqualRgn(rgnA: RgnHandle;rgnB: RgnHandle): BOOLEAN;
  654.     INLINE $A8E3;
  655. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  656.     INLINE $A8E2;
  657. PROCEDURE FrameRgn(rgn: RgnHandle);
  658.     INLINE $A8D2;
  659. PROCEDURE PaintRgn(rgn: RgnHandle);
  660.     INLINE $A8D3;
  661. PROCEDURE EraseRgn(rgn: RgnHandle);
  662.     INLINE $A8D4;
  663. PROCEDURE InvertRgn(rgn: RgnHandle);
  664.     INLINE $A8D5;
  665. PROCEDURE FillRgn(rgn: RgnHandle;pat: Pattern);
  666.     INLINE $A8D6;
  667. PROCEDURE ScrollRect(r: Rect;dh: INTEGER;dv: INTEGER;updateRgn: RgnHandle);
  668.     INLINE $A8EF;
  669. PROCEDURE CopyBits(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  670.     mode: INTEGER;maskRgn: RgnHandle);
  671.     INLINE $A8EC;
  672. PROCEDURE SeedFill(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  673.     height: INTEGER;words: INTEGER;seedH: INTEGER;seedV: INTEGER);
  674.     INLINE $A839;
  675. PROCEDURE CalcMask(srcPtr: Ptr;dstPtr: Ptr;srcRow: INTEGER;dstRow: INTEGER;
  676.     height: INTEGER;words: INTEGER);
  677.     INLINE $A838;
  678. PROCEDURE CopyMask(srcBits: BitMap;maskBits: BitMap;dstBits: BitMap;srcRect: Rect;
  679.     maskRect: Rect;dstRect: Rect);
  680.     INLINE $A817;
  681. FUNCTION OpenPicture(picFrame: Rect): PicHandle;
  682.     INLINE $A8F3;
  683. PROCEDURE PicComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  684.     INLINE $A8F2;
  685. PROCEDURE ClosePicture;
  686.     INLINE $A8F4;
  687. PROCEDURE DrawPicture(myPicture: PicHandle;dstRect: Rect);
  688.     INLINE $A8F6;
  689. PROCEDURE KillPicture(myPicture: PicHandle);
  690.     INLINE $A8F5;
  691. FUNCTION OpenPoly: PolyHandle;
  692.     INLINE $A8CB;
  693. PROCEDURE ClosePoly;
  694.     INLINE $A8CC;
  695. PROCEDURE KillPoly(poly: PolyHandle);
  696.     INLINE $A8CD;
  697. PROCEDURE OffsetPoly(poly: PolyHandle;dh: INTEGER;dv: INTEGER);
  698.     INLINE $A8CE;
  699. PROCEDURE FramePoly(poly: PolyHandle);
  700.     INLINE $A8C6;
  701. PROCEDURE PaintPoly(poly: PolyHandle);
  702.     INLINE $A8C7;
  703. PROCEDURE ErasePoly(poly: PolyHandle);
  704.     INLINE $A8C8;
  705. PROCEDURE InvertPoly(poly: PolyHandle);
  706.     INLINE $A8C9;
  707. PROCEDURE FillPoly(poly: PolyHandle;pat: Pattern);
  708.     INLINE $A8CA;
  709. PROCEDURE SetPt(VAR pt: Point;h: INTEGER;v: INTEGER);
  710.     INLINE $A880;
  711. PROCEDURE LocalToGlobal(VAR pt: Point);
  712.     INLINE $A870;
  713. PROCEDURE GlobalToLocal(VAR pt: Point);
  714.     INLINE $A871;
  715. FUNCTION Random: INTEGER;
  716.     INLINE $A861;
  717. PROCEDURE StuffHex(thingPtr: Ptr;s: Str255);
  718.     INLINE $A866;
  719. FUNCTION GetPixel(h: INTEGER;v: INTEGER): BOOLEAN;
  720.     INLINE $A865;
  721. PROCEDURE ScalePt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  722.     INLINE $A8F8;
  723. PROCEDURE MapPt(VAR pt: Point;srcRect: Rect;dstRect: Rect);
  724.     INLINE $A8F9;
  725. PROCEDURE MapRect(VAR r: Rect;srcRect: Rect;dstRect: Rect);
  726.     INLINE $A8FA;
  727. PROCEDURE MapRgn(rgn: RgnHandle;srcRect: Rect;dstRect: Rect);
  728.     INLINE $A8FB;
  729. PROCEDURE MapPoly(poly: PolyHandle;srcRect: Rect;dstRect: Rect);
  730.     INLINE $A8FC;
  731. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  732.     INLINE $A8EA;
  733. PROCEDURE StdRect(verb: GrafVerb;r: Rect);
  734.     INLINE $A8A0;
  735. PROCEDURE StdRRect(verb: GrafVerb;r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER);
  736.     INLINE $A8AF;
  737. PROCEDURE StdOval(verb: GrafVerb;r: Rect);
  738.     INLINE $A8B6;
  739. PROCEDURE StdArc(verb: GrafVerb;r: Rect;startAngle: INTEGER;arcAngle: INTEGER);
  740.     INLINE $A8BD;
  741. PROCEDURE StdPoly(verb: GrafVerb;poly: PolyHandle);
  742.     INLINE $A8C5;
  743. PROCEDURE StdRgn(verb: GrafVerb;rgn: RgnHandle);
  744.     INLINE $A8D1;
  745. PROCEDURE StdBits(srcBits: BitMap;srcRect: Rect;dstRect: Rect;mode: INTEGER;
  746.     maskRgn: RgnHandle);
  747.     INLINE $A8EB;
  748. PROCEDURE StdComment(kind: INTEGER;dataSize: INTEGER;dataHandle: Handle);
  749.     INLINE $A8F1;
  750. FUNCTION StdTxMeas(byteCount: INTEGER;textAddr: Ptr;VAR numer: Point;VAR denom: Point;
  751.     VAR info: FontInfo): INTEGER;
  752.     INLINE $A8ED;
  753. PROCEDURE StdGetPic(dataPtr: Ptr;byteCount: INTEGER);
  754.     INLINE $A8EE;
  755. PROCEDURE StdPutPic(dataPtr: Ptr;byteCount: INTEGER);
  756.     INLINE $A8F0;
  757. PROCEDURE AddPt(src: Point;VAR dst: Point);
  758.     INLINE $A87E;
  759. FUNCTION EqualPt(pt1: Point;pt2: Point): BOOLEAN;
  760.     INLINE $A881;
  761. FUNCTION PtInRect(pt: Point;r: Rect): BOOLEAN;
  762.     INLINE $A8AD;
  763. PROCEDURE Pt2Rect(pt1: Point;pt2: Point;VAR dstRect: Rect);
  764.     INLINE $A8AC;
  765. PROCEDURE PtToAngle(r: Rect;pt: Point;VAR angle: INTEGER);
  766.     INLINE $A8C3;
  767. FUNCTION PtInRgn(pt: Point;rgn: RgnHandle): BOOLEAN;
  768.     INLINE $A8E8;
  769. PROCEDURE StdText(count: INTEGER;textAddr: Ptr;numer: Point;denom: Point);
  770.     INLINE $A882;
  771. PROCEDURE StdLine(newPt: Point);
  772.     INLINE $A890;
  773. PROCEDURE OpenCPort(port: CGrafPtr);
  774.     INLINE $AA00;
  775. PROCEDURE InitCPort(port: CGrafPtr);
  776.     INLINE $AA01;
  777. PROCEDURE CloseCPort(port: CGrafPtr);
  778.     INLINE $A87D;
  779. FUNCTION NewPixMap: PixMapHandle;
  780.     INLINE $AA03;
  781. PROCEDURE DisposPixMap(pm: PixMapHandle);
  782.     INLINE $AA04;
  783. PROCEDURE CopyPixMap(srcPM: PixMapHandle;dstPM: PixMapHandle);
  784.     INLINE $AA05;
  785. FUNCTION NewPixPat: PixPatHandle;
  786.     INLINE $AA07;
  787. PROCEDURE DisposPixPat(pp: PixPatHandle);
  788.     INLINE $AA08;
  789. PROCEDURE CopyPixPat(srcPP: PixPatHandle;dstPP: PixPatHandle);
  790.     INLINE $AA09;
  791. PROCEDURE PenPixPat(pp: PixPatHandle);
  792.     INLINE $AA0A;
  793. PROCEDURE BackPixPat(pp: PixPatHandle);
  794.     INLINE $AA0B;
  795. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  796.     INLINE $AA0C;
  797. PROCEDURE MakeRGBPat(pp: PixPatHandle;myColor: RGBColor);
  798.     INLINE $AA0D;
  799. PROCEDURE FillCRect(r: Rect;pp: PixPatHandle);
  800.     INLINE $AA0E;
  801. PROCEDURE FillCOval(r: Rect;pp: PixPatHandle);
  802.     INLINE $AA0F;
  803. PROCEDURE FillCRoundRect(r: Rect;ovalWidth: INTEGER;ovalHeight: INTEGER;
  804.     pp: PixPatHandle);
  805.     INLINE $AA10;
  806. PROCEDURE FillCArc(r: Rect;startAngle: INTEGER;arcAngle: INTEGER;pp: PixPatHandle);
  807.     INLINE $AA11;
  808. PROCEDURE FillCRgn(rgn: RgnHandle;pp: PixPatHandle);
  809.     INLINE $AA12;
  810. PROCEDURE FillCPoly(poly: PolyHandle;pp: PixPatHandle);
  811.     INLINE $AA13;
  812. PROCEDURE RGBForeColor(color: RGBColor);
  813.     INLINE $AA14;
  814. PROCEDURE RGBBackColor(color: RGBColor);
  815.     INLINE $AA15;
  816. PROCEDURE SetCPixel(h: INTEGER;v: INTEGER;cPix: RGBColor);
  817.     INLINE $AA16;
  818. PROCEDURE SetPortPix(pm: PixMapHandle);
  819.     INLINE $AA06;
  820. PROCEDURE GetCPixel(h: INTEGER;v: INTEGER;VAR cPix: RGBColor);
  821.     INLINE $AA17;
  822. PROCEDURE GetForeColor(VAR color: RGBColor);
  823.     INLINE $AA19;
  824. PROCEDURE GetBackColor(VAR color: RGBColor);
  825.     INLINE $AA1A;
  826. PROCEDURE SeedCFill(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  827.     seedH: INTEGER;seedV: INTEGER;matchProc: ProcPtr;matchData: LONGINT);
  828.     INLINE $AA50;
  829. PROCEDURE CalcCMask(srcBits: BitMap;dstBits: BitMap;srcRect: Rect;dstRect: Rect;
  830.     seedRGB: RGBColor;matchProc: ProcPtr;matchData: LONGINT);
  831.     INLINE $AA4F;
  832. PROCEDURE OpColor(color: RGBColor);
  833.     INLINE $AA21;
  834. PROCEDURE HiliteColor(color: RGBColor);
  835.     INLINE $AA22;
  836. PROCEDURE DisposCTable(cTable: CTabHandle);
  837.     INLINE $AA24;
  838. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  839.     INLINE $AA18;
  840. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  841.     INLINE $AA1B;
  842. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  843.     INLINE $AA1C;
  844. PROCEDURE AllocCursor;
  845.     INLINE $AA1D;
  846. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  847.     INLINE $AA26;
  848. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  849.     INLINE $AA1E;
  850. PROCEDURE PlotCIcon(theRect: Rect;theIcon: CIconHandle);
  851.     INLINE $AA1F;
  852. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  853.     INLINE $AA25;
  854. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  855.     INLINE $AA4E;
  856. PROCEDURE CharExtra(extra: Fixed);
  857.     INLINE $AA23;
  858. FUNCTION GetMaxDevice(globalRect: Rect): GDHandle;
  859.     INLINE $AA27;
  860. FUNCTION GetCTSeed: LONGINT;
  861.     INLINE $AA28;
  862. FUNCTION GetDeviceList: GDHandle;
  863.     INLINE $AA29;
  864. FUNCTION GetMainDevice: GDHandle;
  865.     INLINE $AA2A;
  866. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  867.     INLINE $AA2B;
  868. FUNCTION TestDeviceAttribute(gdh: GDHandle;attribute: INTEGER): BOOLEAN;
  869.     INLINE $AA2C;
  870. PROCEDURE SetDeviceAttribute(gdh: GDHandle;attribute: INTEGER;value: BOOLEAN);
  871.     INLINE $AA2D;
  872. PROCEDURE InitGDevice(qdRefNum: INTEGER;mode: LONGINT;gdh: GDHandle);
  873.     INLINE $AA2E;
  874. FUNCTION NewGDevice(refNum: INTEGER;mode: LONGINT): GDHandle;
  875.     INLINE $AA2F;
  876. PROCEDURE DisposGDevice(gdh: GDHandle);
  877.     INLINE $AA30;
  878. PROCEDURE SetGDevice(gd: GDHandle);
  879.     INLINE $AA31;
  880. FUNCTION GetGDevice: GDHandle;
  881.     INLINE $AA32;
  882. FUNCTION Color2Index(myColor: RGBColor): LONGINT;
  883.     INLINE $AA33;
  884. PROCEDURE Index2Color(index: LONGINT;VAR aColor: RGBColor);
  885.     INLINE $AA34;
  886. PROCEDURE InvertColor(VAR myColor: RGBColor);
  887.     INLINE $AA35;
  888. FUNCTION RealColor(color: RGBColor): BOOLEAN;
  889.     INLINE $AA36;
  890. PROCEDURE GetSubTable(myColors: CTabHandle;iTabRes: INTEGER;targetTbl: CTabHandle);
  891.     INLINE $AA37;
  892. PROCEDURE MakeITable(cTabH: CTabHandle;iTabH: ITabHandle;res: INTEGER);
  893.     INLINE $AA39;
  894. PROCEDURE AddSearch(searchProc: ProcPtr);
  895.     INLINE $AA3A;
  896. PROCEDURE AddComp(compProc: ProcPtr);
  897.     INLINE $AA3B;
  898. PROCEDURE DelSearch(searchProc: ProcPtr);
  899.     INLINE $AA4C;
  900. PROCEDURE DelComp(compProc: ProcPtr);
  901.     INLINE $AA4D;
  902. PROCEDURE SubPt(src: Point;VAR dst: Point);
  903.     INLINE $A87F;
  904. PROCEDURE SetClientID(id: INTEGER);
  905.     INLINE $AA3C;
  906. PROCEDURE ProtectEntry(index: INTEGER;protect: BOOLEAN);
  907.     INLINE $AA3D;
  908. PROCEDURE ReserveEntry(index: INTEGER;reserve: BOOLEAN);
  909.     INLINE $AA3E;
  910. PROCEDURE SetEntries(start: INTEGER;count: INTEGER;aTable: CSpecArray);
  911.     INLINE $AA3F;
  912. PROCEDURE SaveEntries(srcTable: CTabHandle;resultTable: CTabHandle;VAR selection: ReqListRec);
  913.     INLINE $AA49;
  914. PROCEDURE RestoreEntries(srcTable: CTabHandle;dstTable: CTabHandle;VAR selection: ReqListRec);
  915.     INLINE $AA4A;
  916. FUNCTION QDError: INTEGER;
  917.     INLINE $AA40;
  918. FUNCTION GetMaskTable: Ptr;
  919.  
  920. {$ENDC}    { UsingQuickdraw }
  921.  
  922. {$IFC NOT UsingIncludes}
  923.     END.
  924. {$ENDC}
  925.  
  926.